﻿#define _CRT_SECURE_NO_WARNINGS

//#include<iostream>
//#include<stdio.h>
//#include<stdlib.h>
//using namespace std;


//namespace ahead {
//	int rand = 9;
//}
//using namespace ahead;
//int fun()
//{
//	int a =1;
//	int b =2;
//	return a + b;
//}
//
//int fun(int a = 1)
//{
//	int b = 2;
//	return a + b;
//}
//
//int main()
//{
//	//fun();
//	//printf("rand = %d", rand);
//	//cout << "hello word" << endl; //end line 结束一行即换行
//	//cout可以理解为控制台  << 输出符号
//	int a = 0;
//	std::cout << "请输入一个数：" ;
//	std::cin >> a;
//	std::cout << a << std::endl; //end line 结束一行即换行
//	return 0;
//}



//#include<iostream>
//
//void fun1(int a = 1, int b = 2, int c = 3);
//void fun2(int a, int b = 2, int c = 3);
//
////缺省参数
//
////全缺省参数
//void fun1(int a = 1, int b = 2,int c = 3)
//{
//	std::cout << "a + b + c = " << a + b +c  << std::endl;
//}
//
////半缺省参数
//void fun2(int a , int b = 2, int c = 3)
//{
//	std::cout << "b + c - a = " << c + b - a << std::endl;
//}
//
//int main()
//{
//	//全缺省参数
//	fun1();
//	fun1(1);
//	fun1(1, 3);
//	fun1(1, 3, 4);
//
//	//半缺省参数
//	fun2(2);
//	fun2(2,3);
//	fun2(2, 3, 4);
//	return 0;
//}


//#include<iostream>
//
////参数个数不同
//int Mul(int a, int b)
//{
//	std::cout << "int Mul(int a, int b)" << std::endl;
//	return a * b;
//}
//
//int Mul(int a, int b,int c)
//{
//	std::cout << "int Mul(int a, int b,int c)" << std::endl;
//	return a * b * c;
//}
//
////参数类型不同
//
//int Add(int a,int b)
//{
//	std::cout << "int Add(int a,int b)" << std::endl;
//	return a + b;
//}
//
//double Add(double a, double b)
//{
//	std::cout << "double Add(double a, double b)" << std::endl;
//	return a + b;
//}
//
//
//
////参数顺序不同
//void fun(int a, char c)
//{
//	std::cout << "void fun(int a, char c)" << std::endl;
//}
//
//void fun(char c, int a)
//{
//	std::cout << "void fun(char c, int a)" << std::endl;
//}
//
//
////下面两个函数构成函数重载
////但调用可能会出现二义性：编译器无法判断调用那个
//void f()
//{
//	std::cout << "void f()" << std::endl;
//}
//
//void f(int a = 2)
//{
//	std::cout << "void f(int a = 2)" << std::endl;
//}
//
//int main()
//{
//	//参数个数不同
//	Mul(1, 2);
//	Mul(1, 2, 3);
//
//	//参数类型不同
//	Add(2,3);
//	Add(2.3, 3.5);
//
//	//参数顺序不同
//	fun(1, 'a');
//	fun('a', 1);
//
//	//无法判断调用那个
//	//f();
//	f(1);
//
//	return 0;
//}






//#include<iostream>
//
////引⽤在定义时必须初始化，即定义时必须给定引⽤对象（在本例中就是变量a）
//
////⼀个变量可以有多个引⽤
//
////引⽤⼀旦引⽤⼀个实体，再不能引⽤其他实体
//
//
//int& getLarger(int& a, int& b) {
//	return (a > b) ? a : b;
//}
//int main()
//{
//	int a = 10;
//
//	//⼀个变量可以有多个引⽤
//	int& ra0 = a;
//	int& ra1 = a;
//	int& ra2 = a;
//
//	int num1 = 10;
//	int num2 = 20;
//	int& result = getLarger(num1, num2);
//	std::cout << result << std::endl;
//
//	int a = 10;
//	int& rb = a * 3;
//	double d = 12.34;
//	int& rd = d;
//
//
//	return 0;
//}


//错误
//int& badFunction() {
//	int Num = 10;
//	return Num;
//}
// 
// 

 
//#include<iostream>
//
//// 为什么不能加分号?
//// #define ADD(a, b) ((a) + (b));
//// 
////为什么要加外面的括号？
////#define ADD(a, b) (a) + (b)
//
////为什么要加里面的括号？
//#define ADD(a, b) ((a) + (b))
//
////正确
//#define ADD(a, b) (a + b)
//
//int main() {
//
//	// 为什么不能加分号?
//	int a = 10;
//	int b = 5;
//	int sum = ADD(1, 2);
//	//到时会替换成int sum = ((10) + (5));;
//	//两个;;显得多余，还会干扰正常的语法结构
//
//
//	int num = 100;
//	//if后面的括号里有;会报错
//	//if (num > ((10) + (5));)
//	/*if (num > ADD(1, 2))
//	{
//		std::cout << num << std::endl;
//	}*/
//
//
//	//为什么要加外面的括号？
//	//加外面的括号是为了保证整个宏展开后的表达式优先级正确。
//	int result = 3 * ADD(3, 4);
//	//看上去 3 * ADD(3, 4) = 3 * (3 + 4) = 21
//
//	std::cout << result << std::endl;
//	//实际上3 * ADD(3, 4) = 3* (3) + (4) = 13
//
//
//	int x = 1;
//	int y = 2;
//	int n = ADD(x|y , x&y);
//
//
//	return 0;
//}




//#include<iostream>
//
////nullptr
//
//void f(int x)
//{
//	std::cout << "void f(int x)" << std::endl;
//}
//
//void f(int* ptr)
//{
//	std::cout << "void f(int* ptr)" << std::endl;
//}
//
//int main() {
//
//	f(0);
//	f(NULL);
//
//	//error C2665: “f”: 没有重载函数可以转换所有参数类型
//	//f((void*)NULL);
//
//	f(nullptr);
//
//	return 0;
//}


//下⾯程序编译运⾏结果是（） ?
//? ? A、编译报错 ? ? B、运⾏崩溃 ? ? C、正常运⾏ ?
#include<iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "A::Print()" << endl;
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

// B
//当执行到cout << _a << endl;时，由于this指针（在这里就是p，其值为nullptr）是无效的，
// 尝试通过nullptr去访问成员变量_a就会导致访问违规。
// 这种访问违规在运行时会引发段错误（segmentation fault）或者访问冲突，从而导致程序崩溃。